//package com.yzf.demo.demo.array;
//
//import java.util.AbstractList;
//import java.util.Arrays;
//import java.util.List;
//import java.util.RandomAccess;
//
///**
// * Created by 于占峰 on 2020/3/26/026.
// * ArrayList实例
// */
//public class ArrayListDemoBean<E> extends AbstractList implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
//
//    private static final long serialVersionUID = 8683452581122892189L;
//    /**
//     * 默认的长度
//     */
//    private static final int DEFAULT_CAPACITY = 10;
//
//    /**
//     * Shared empty array instance used for empty instances.
//     * 空的数组对象
//     */
//    private static final Object[] EMPTY_ELEMENTDATA = {};
//
//    /**
//     * Shared empty array instance used for default sized empty instances. We
//     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
//     * first element is added.
//     * 空的数组对象
//     */
//    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//
//    /**
//     *最终存储数据的数组结构
//     */
//    transient Object[] elementData; // non-private to simplify nested class access
//
//    /**
//     * 存储的数据个数
//     *
//     * @serial
//     */
//    private int size;
//
//    //Array存储上限
//    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//
//    /**
//     * 带参数构造器 如果传递参数则对elementData进行真正意义上的初始化
//     *
//     */
//    public ArrayListDemoBean(int initialCapacity) {
//        if (initialCapacity > 0) {
//            this.elementData = new Object[initialCapacity];
//        } else if (initialCapacity == 0) {
//            this.elementData = EMPTY_ELEMENTDATA;
//        } else {
//            throw new IllegalArgumentException("Illegal Capacity: "+
//                    initialCapacity);
//        }
//    }
//
//    /**
//     * 默认无参数初始化 将elementData赋值为一个空的数组对象 可以节省资源
//     */
//    public ArrayListDemoBean() {
//        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
//    }
//
//
//
//
//    public boolean add(Object e) {
//        //1.在真正添加数据时会判断是否有足够的空间存储数据 如果没有则扩容
//        //调用 ensureCapacityInternal 传入当前存储数据数量+1(预计存储需要的最小数组长度)
//        ensureCapacityInternal(size + 1);  // Increments modCount!!
//        //7.将需要存储的数据添加到 elementData数组的size++(最大数据的下一个下标,也就是已有数据的最后一        //位的下一位)并返回true 添加成功
//        elementData[size++] = e;
//        return true;
//    }
//
//
//
//
//    private void ensureCapacityInternal(int minCapacity) {
//        //2.先执行calculateCapacity(elementData, minCapacity)
//        //5.执行 ensureExplicitCapacity
//        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
//    }
//
//    private static int calculateCapacity(Object[] elementData, int minCapacity) {
//        // 3.判断elementData是否为空的数组
//        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//            //4. DEFAULT_CAPACITY默认值为10 将传递过来的最小存储数据需要长度与默认长度进行比较
//            //并将两者最大的那个返回给 ensureExplicitCapacity
//            return Math.max(DEFAULT_CAPACITY, minCapacity);
//        }
//        //4.如果已经存储过数据 则将传递过来的存储数据需要的最小长度 返回给ensureExplicitCapacity
//        return minCapacity;
//    }
//
//    private void ensureExplicitCapacity(int minCapacity) {
//        //统计内部结构修改次数的变量
//        modCount++;
//
//        // overflow-conscious code
//        //6.如果当前需要的最小存储长度minCapacity减去elementData的当前数组长度大于0 则执行grow扩容
//        if (minCapacity - elementData.length > 0)
//            grow(minCapacity);
//    }
//
//    private void grow(int minCapacity) {
//        //6.扩容处理
//        // overflow-conscious code
//        //实际存储数据的数组长度
//        int oldCapacity = elementData.length;
//        //通过原数组长度+原数组长度一半 得到新的数组长度
//        int newCapacity = oldCapacity + (oldCapacity >> 1);
//        //判断新的数组长度减去需要当前存储数据的最小长度是否小于0
//        if (newCapacity - minCapacity < 0)
//            //如果满足条件则新的数组长度为默认的10
//            newCapacity = minCapacity;
//        //判断新的数组长度减去最大长度上限MAX_ARRAY_SIZE(0x7fffffff - 8)是否大于零 基本不会满足吧?
//        if (newCapacity - MAX_ARRAY_SIZE > 0)
//            newCapacity = hugeCapacity(minCapacity);
//        // minCapacity is usually close to size, so this is a win:
//        //进行数组拷贝 将newCapacity拷贝到一个长度为newCapacity的数组 并赋值给elementData
//        //elementData = Arrays.copyOf(newCapacity, newCapacity);
//    }
//
//    private static int hugeCapacity(int minCapacity) {
//        if (minCapacity < 0) // overflow
//            throw new OutOfMemoryError();
//        return (minCapacity > MAX_ARRAY_SIZE) ?
//                Integer.MAX_VALUE :
//                MAX_ARRAY_SIZE;
//    }
//
//
//
//
//
//    @Override
//    public int size() {
//        return 0;
//    }
//    @Override
//    public E get(int index) {
//        return null;
//    }
//
//
//}
